
const arr = {

    /**
     * 
     * @param {Array|Object[]} a 目标数组
     * @param {String} field 
     */
    pluck(a, field, key = null) {
        if (key === null) {
            var res = []
        } else {
            var res = {}
        }
        for (let i in a) {
            if (key === null) {
                res.push(a[i][field]);
            } else {
                res[a[i][key]] = a[i][field];
            }
        }
        return res;
    },

    /**
     * 合并a和b，如果有相同key，则b中的value覆盖a的
     * @param {Object} a 
     * @param {Object} b 
     * @returns 
     */
    merge(a, b) {
        let r = a;
        for (let i in b) {
            a[i] = b[i];
        }
        return r;
    },

    /**
     * 
     * @param {Object} a 
     * @param {String} key 
     * @param {any} defaultValue 
     */
    get(a, key, defaultValue = '') {
        if ('number' === typeof key) {
            return a[key] === undefined ? defaultValue : a[key];
        }
        let dotIdx = key.indexOf('.')
        if (dotIdx === -1) {
            return a[key] === undefined ? defaultValue : a[key];
        }
        let k1 = key.substring(0, dotIdx);
        if (a[k1] === undefined) {
            return defaultValue;
        }
        return arr.get(a[k1], key.substring(dotIdx + 1), defaultValue)
    },

    /**
     * 转换字段的类型，主要用在select的默认选中
     * @param {*} a 
     * @param {object} opt {fieldName:type, id:'string'}
     */
    coverFieldType(a, opt, recursion = true) {
        if (Array.isArray(a)) {
            a.forEach((item, idx) => {
                a[idx] = arr.coverFieldType(item, opt, recursion)
            })
            return a;
        }
        for (let k in opt) {
            if (a[k] === undefined) {
                continue;
            }
            if ('object' === typeof a[k]) {
                if (recursion) {
                    a[k] = arr.coverFieldType(a[k], opt, recursion);
                }
                continue;
            }
            let t = opt[k];
            if (t === 'string') {
                a[k] = '' + a[k]
            } else if (t === 'number') {
                a[k] = 1 * a[k]
            } else if (t === 'int') {
                a[k] = parseInt(a[k])
            }
        }
        return a;
    },

    /**
     * 将目标数组按指定长度进行切割成二维数组
     * @param {Array} array 原数组
     * @param {Number} size 分割长度
     */
    chunk(array, size) {
        const length = array.length
        //判断不是数组，或者size没有设置，size小于1，就返回空数组
        if (!length || !size || size < 1) {
            return []
        }
        //核心部分
        let index = 0 //用来表示切割元素的范围start
        let resIndex = 0 //用来递增表示输出数组的下标

        //根据length和size算出输出数组的长度，并且创建它。
        let result = new Array(Math.ceil(length / size))
        //进行循环
        while (index < length) {
            //循环过程中设置result[0]和result[1]的值。该值根据array.slice切割得到。
            result[resIndex++] = array.slice(index, (index += size))
        }
        //输出新数组
        return result

    }
}

export default arr